home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / yase.arc / LINEED.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-12-13  |  7.6 KB  |  220 lines
  1. ******************************************************************
  2. * COPYRIGHT (C) 1986 by Donald Krantz and James Stanley
  3. * - Note: This is a real, live, actual, registered copyright,
  4. *   and should be treated as such. This source code is from
  5. *   the book "68000 Assembly Language", Krantz and Stanley,
  6. *   Addison-Wesley Publishing Company, Reading, MA, 1986.
  7. * 
  8. *   Permission granted by the authors for non-commercial use
  9. *   in programs released to the public domain, as long as this
  10. *   copyright notice remains attached and visible.
  11. *
  12. *****************************************************************
  13. * LINEED - Input line editor. Does editing into a string from
  14. * a CRT device. Supports default value prompting.
  15. *
  16. *    ENTRY:    P0.L is the address of the receiving string
  17. *        P1.W is the screen line number to start editing
  18. *        P2.W is the screen column.
  19. *        P3.W is the max number of screen columns allowed
  20.  
  21. #cursor.h
  22.  
  23.     .xdef    lineed
  24.     .xref    case,cursor,putc,_getkey
  25.  
  26. * The following symbol (and references thereto) required only if
  27. * using the VSCREEN virtual CRT interface.
  28.     .xref    sync_curs    
  29.  
  30. string    equ    8        * Stack frame offsets
  31. line    equ    12        * offset to editing line
  32. column    equ    14        * offset to first editing column
  33. max    equ    16        * offset to max editing cols.
  34.  
  35. *****************************************************************
  36. lineed:
  37.     link    a6,#0        * Establish stack frame
  38.     movem.l    d0-d7/a0-a3,-(a7) * Save caller's registers.
  39.     move.w    max(a6),d7    * get maximum usable column
  40.     add.w    column(a6),d7    * compute max crt column 
  41.     subq.w    #1,d7        * adjust for tests later
  42.     clr.w    D3        * Initialize string index
  43.      move.l    string(a6),a1    * get string base address
  44. loop:
  45.     bsr    update        * update display
  46.     bsr    _getkey        * Get next input key
  47.     move.l    #dispatch,a0    * setup case statement
  48.     bsr    case        * case selector already in D0.
  49.     bra    loop        * end of editing loop.
  50. *****************************************************************
  51. * Branches here when human presses RETURN key.
  52. finis:
  53.     clr.b    0(a1,d3.w)    * Terminate input string w/ null
  54.     addq.l    #4,a7        * Trash last return address
  55.     movem.l    (a7)+,d0-d7/a0-a3 * Restore caller's register
  56.     unlk    a6        * Restore caller's stack frame
  57.     rts
  58. *****************************************************************
  59. * Branches here to display 'old' stuff past cursor.
  60. to_end:
  61.     tst.b    0(a1,d3.w)    * are we pointing at terminal?
  62.     beq    sk1_te        * yes - no action required
  63.     addq.w    #1,d3        * move index up one.
  64.     bra    to_end        * repeat
  65. sk1_te:
  66.     rts
  67. *****************************************************************
  68. * Branches here to return cursor to start of line
  69. to_start:
  70.     clr.w    d3        * Set index to start
  71.     rts
  72. *****************************************************************
  73. * branches here to move the cursor one character to the left. 
  74. left:
  75.     tst.w    d3        * are we at start of line?
  76.     beq    exit_left    * yes, let's blow this popstand
  77.     subq.w    #1,d3        * Index back one character
  78. exit_left:
  79.     rts
  80. ****************************************************************
  81. * Moves the cursor one character to the right.
  82. right:
  83.     tst.b    0(a1,d3.w)    * Is there more stuff to display?
  84.     beq    exit_ri        * Nope, we're done here.
  85.     addq.w    #1,d3        * add one to character index
  86. exit_ri:
  87.     rts
  88. *****************************************************************
  89. * Branch here to delete one character to the right
  90. d_right:
  91.     lea    0(a1,d3.w),a2    * load destination address
  92.     tst.b    (a2)        * check for end of string
  93.     beq    exit_dr        * no need to do anything.
  94.     lea    1(a1,d3.w),a3    * load source address
  95.     move.w    max(a6),D1    * Get max char count
  96.     sub    d3,d1        * Compute transfer count
  97. lp0_dr:
  98.     move.b    (a3)+,(a2)+    * start moving the string in
  99.     dbra    d1,lp0_dr    * do whole string.
  100. exit_dr:
  101.     rts
  102. *****************************************************************
  103. * Branch here to delete one character to the left
  104. d_left:
  105.     tst.w    d3        * Are we at start of string?
  106.     beq    exit_dl        * Yes, no action required.
  107.     bsr    left        * Move cursor one char left
  108.     bra    d_right        * re-use d_right code.
  109. exit_dl:
  110.     rts
  111. *****************************************************************
  112. * Branch here to accept next key typed as a literal
  113. jamload:
  114.     bsr    _getkey        * get next key
  115.     bra    othrs        * shove it in.
  116. *****************************************************************
  117. * Inserts the typed character at the cursor.
  118. others:
  119.     cmp.b    #' ',d0        * Test for valid character
  120.     blt    exit_ot        * No, less than $20, ignore
  121. othrs:
  122.     move.w    max(a6),D1    * Get max char count
  123.     ext.l    d1        * setup for address arithmetic
  124.     lea    -1(a1),a2    * load source address
  125.     add.l    d1,a2        * start at far end of string
  126.     lea    0(a1),a3    * load destination address
  127.     add.l    d1,a3        * start at far end of string
  128.     sub.w    d3,d1        * get transfer count
  129.     bra    sk0_ot        * do dec/tst before first xfer
  130. lp0_ot:
  131.     move.b    -(a2),-(a3)    * start moving the string out
  132. sk0_ot:
  133.     dbra    d1,lp0_ot    * loop over end of string.
  134.     move.w    max(a6),d1    * terminate string, in case of -
  135.     clr.b    (a1,d1.w)    *   overflow into terminal null
  136.     move.b    d0,0(a1,d3.w)    * insert new character
  137.     addq.w    #1,d3        * move string index.
  138. exit_ot:
  139.     rts
  140. *****************************************************************
  141. * prints the character in D0, expanding control chars as req.
  142. c_print:
  143.     move.w    d0,-(a7)    * save character on stack
  144.     cmp.b    #$20,d0        * check if it's a control char
  145.     bge    sk0_cp        * no, just print it.
  146.     move.w    #$005E,-(a7)    * push a circumflex for a prefix
  147.     bsr    putc        * print at cursor.
  148.     addq.l    #2,a7        * restore stack
  149.     add.w    #$0040,(a7)    * make unprintable printable
  150.     addq.w    #1,d1        * increment column
  151. sk0_cp:
  152.     bsr    putc        * put input char, already on stack
  153.     addq.l    #2,a7        * restore stack
  154.     addq.w    #1,d1        * increment column
  155.     rts
  156. *****************************************************************
  157. * Prints the input string and updates cursor
  158. update:
  159.     move.w    line(a6),-(a7)    * set cursor to start of line
  160.     move.w    column(a6),-(a7)  this is X, above is Y
  161.     bsr    cursor        * sets cursor to start
  162.     addq.l    #4,a7        * fix stack
  163.     move.w    column(a6),d1    * d1 will be cursor posit
  164.     clr.w    d4        * d4 will be counter
  165. lp0_sp:
  166.     cmp.w    d4,d3        * are we at cursor?
  167.     bne    sk0_sp        * no, jump
  168.     move.w    d1,d5        * save screen cursor position
  169. sk0_sp:    
  170.     move.b    0(a1,d4.w),d0    * char to print
  171.     beq    sk1_sp        * jump out if it's a null
  172.     bsr    c_print        * output character
  173.     addq.w    #1,d4        * bump character counter
  174.     cmp.w    d1,d7        * test for end of area
  175.     bge    lp0_sp        * repeat if there's room.
  176. sk1_sp:
  177.     cmp    d4,d3        * did we find cursor?
  178.     ble    sk2_sp        * yes, we already found it.
  179.     move.w    d4,d3        * reset string counter
  180.     subq.w    #1,d3        * adjust because d4 incremented
  181.     bra    update        * resync all the pointers
  182. sk2_sp:
  183.     move.b    #' ',d0        * blank rest of edit area
  184.     cmp.w    d1,d7        * did we output enough yet?
  185.     blt    sk3_sp        * jump if we did
  186.     bsr    c_print        * put a blank
  187.     bra    sk2_sp        * try again
  188. sk3_sp:
  189.     move.w    line(a6),-(a7)    * reset cursor
  190.     move.w    d5,-(a7)    * this is cursor position
  191.     bsr    cursor        * now tell the display
  192.     addq.l    #4,a7        * fix stack
  193.     bsr    sync_curs    * only needed if using vscreen
  194.     rts
  195. *****************************************************************
  196. * Input character dispatch table
  197. dispatch:
  198.     dc.w    9        * Case options count
  199.     dc.w    return        * when return => finis
  200.     dc.l    finis
  201.     dc.w    c_w_right    * when c_w_right => to_end
  202.     dc.l    to_end
  203.     dc.w    c_w_left    * when c_w_right => to_start
  204.     dc.l    to_start
  205.     dc.w    c_right        * when c_right => right
  206.     dc.l    right
  207.     dc.w    c_left        * when c_left => left
  208.     dc.l    left
  209.     dc.w    backsp        * when backsp => left
  210.     dc.l    left
  211.     dc.w    left_del    * when left_del => d_left
  212.     dc.l    d_left
  213.     dc.w    right_del    * when right_del => d_right
  214.     dc.l    d_right
  215.     dc.w    lit_prefix    * when lit_prefix => jamload
  216.     dc.l    jamload
  217.     dc.l    others        * default case
  218.  
  219.     end
  220.